package pac

// import (
// 	"fmt"
// 	"strconv"
// 	"sync"
// 	"time"

// 	"slgw_web/serial/dto"
// 	"slgw_web/serial/util"

// 	db "slgw_web/application/gormdb"

// 	// "github.com/goburrow/modbus"
// 	// "openzbox.com/driver/conn/serial"
// 	"openzbox.com/driver/conn/serial"
// 	models "openzbox.com/frame/echo/models/sl_gw01"
// 	"openzbox.com/protocol/modbus"
// )

// var (
// 	test []dto.ModbusRTU
// )

// func init() {
// 	GetSerialInit()
// 	GetSerial_SlavelInit()
// 	Serial_Slave_DetailInit()
// 	RTUClient()
// }

// func CollectNew() {

// }

// var is int

// func RTURestart(id int64) {
// 	for i, _ := range test {
// 		if test[i].DataID == id {
// 			test[i].ClientClient.Close()
// 			//重连
// 			clientClients := modbus.NewClient(test[i].P)
// 			err := clientClients.Connect()
// 			if err != nil {
// 				util.Error("重新打开'" + GetCOMName(test[i].ComName) + "'失败，请检查配置情况:<br>" + err.Error())
// 			}
// 			newData := dto.ModbusRTU{
// 				ClientClient: clientClients,
// 				DataID:       test[i].DataID,
// 				ComName:      test[i].ComName,
// 				//Clients:      clients,
// 				TPITV: test[i].TPITV,
// 				I:     test[i].I,
// 				P:     test[i].P,
// 			}
// 			test[i] = newData
// 			break // 找到后退出循环
// 		}
// 	}
// }
// func RTUClient() {
// 	// 创建Modbus主机
// 	test = test[:0]
// 	for _, data := range util.Serial {
// 		if data.Agreement == "1" { //modbus模式
// 			var p modbus.ClientProvider
// 			var clientClients modbus.Client
// 			if data.ByteMode == "RTU" { //RTU模式
// 				baudRate, err := strconv.Atoi(data.BAD)
// 				if err != nil {
// 					util.Error(data.ComName + "的波特率转换失败")
// 				}
// 				dataBits, err := strconv.Atoi(data.DAB)
// 				if err != nil {
// 					util.Error(data.ComName + "的数据位转换失败")
// 				}
// 				stopBits, err := strconv.Atoi(data.STO)
// 				if err != nil {
// 					util.Error(data.ComName + "的停止位转换失败")
// 				}
// 				p = modbus.NewRTUClientProvider(
// 					// modbus.WithEnableLogger(),
// 					modbus.WithSerialConfig(serial.Config{
// 						Address:  data.ComName,
// 						BaudRate: baudRate,
// 						DataBits: dataBits,
// 						StopBits: stopBits,
// 						Parity:   data.CHC,
// 						Timeout:  time.Duration(util.Timeout) * time.Second,
// 					}),
// 				)
// 				clientClients = modbus.NewClient(p)
// 				err = clientClients.Connect()
// 				if err != nil {
// 					util.Error("modbusRtu打开'" + GetCOMName(data.ComName) + "'失败，请检查配置情况:<br>" + err.Error())
// 				}

// 			} else if data.ByteMode == "TCP" { //TCP模式
// 				p = modbus.NewTCPClientProvider(data.ComName)

// 				clientClients = modbus.NewClient(p)
// 				err := clientClients.Connect()
// 				if err != nil {
// 					util.Error("modbusTcp打开'" + GetCOMName(data.ComName) + "'失败，请检查配置情况:<br>" + err.Error())
// 				}
// 			}

// 			test1 := dto.ModbusRTU{
// 				ClientClient: clientClients,
// 				DataID:       data.ID,
// 				ComName:      data.ComName,
// 				TPITV:        data.TPITV,
// 				I:            is,
// 				P:            p,
// 			}
// 			is++
// 			test = append(test, test1)
// 		}
// 	}
// }

// var countTime = 0   //倒计时
// var countBreak = 40 //最终值
// var count = 0       //等于0的时候才能开始下一个采集的gofunc，每次最后一个采集完毕就变为0
// // var mu sync.Mutex
// var countCopy = 0
// var countCopy2 = 0

// // 定时查询
// func GetDataTime2() {
// 	for {
// 		fmt.Println("countTime", countTime)
// 		fmt.Println("count1", count)
// 		fmt.Println("countCopy", countCopy)
// 		fmt.Println("countCopy2", countCopy2)
// 		if countCopy == count {
// 			countCopy2++
// 		} else {
// 			countCopy = count
// 			countCopy2 = 0
// 		}
// 		if countCopy2 >= 10 {
// 			countBreak = count
// 			countCopy = 0
// 			count = 0
// 			break
// 		}
// 		if count >= countBreak {
// 			count = 0
// 			break
// 		}
// 		if countTime >= 1*60 { //20min后还没有拿到最后一个，说明最后一个count不是计算的那个,有错误，手动更改countBreak
// 			countBreak = count
// 			count = 0
// 			break
// 		}
// 		countTime++
// 		time.Sleep(1000 * time.Millisecond)
// 	}
// 	fmt.Println("countBreak", countBreak)
// 	countTime = 0
// 	for i2, _ := range test {
// 		i := i2

// 		go func() {
// 			//mu.Lock()
// 			// defer mu.Unlock()
// 			for j := range util.Serial_Slave {

// 				data2 := util.Serial_Slave[j]
// 				if data2.Serial_ID == test[i].DataID {
// 					//获取该串口的地址位
// 					slaveIds, err := strconv.Atoi(data2.ModbusSlaveID)
// 					if err != nil {
// 						util.Error(data2.Name + "地址位转换失败")
// 					}
// 					slaveID := byte(slaveIds)
// 					//for _, data3 := range GetTypesBySerialSlaveID(data2.ID) {

// 					//var maxID int64 = 0 // 获取的最大寄存器地址
// 					for _, item := range util.Serial_Slave_Detail {
// 						if item.Serial_ID == test[i].DataID && item.Serial_Slave_ID == data2.ID {
// 							//mu.Lock()

// 							time.Sleep(200 * time.Millisecond)
// 							count++
// 							address := uint16(*item.CollectAddressID) // 寄存器起始地址
// 							quantity := uint16(1)                     // 寄存器数量
// 							data3 := item.Type
// 							if data3 == 1 {
// 								//读功能码01
// 								isSucces := true
// 								results, err := test[i].ClientClient.ReadCoils(slaveID, address, quantity)
// 								if err != nil {
// 									results, err = test[i].ClientClient.ReadCoils(slaveID, address, quantity)
// 									if err != nil {
// 										isSucces = false
// 									}
// 								}
// 								if isSucces {
// 									if len(results) > 0 {
// 										binaryStr := BytesToBinaryString(results)
// 										hexString := GetBinaryString(binaryStr)
// 										AddData(data2.Serial_ID, data2.ID, data3, hexString, item.CollectAddressID)
// 									} else {
// 										deleteArray(data2.Serial_ID, data2.ID, data3, *item.CollectAddressID)
// 									}
// 								}

// 							} else if data3 == 2 {
// 								//读功能码02
// 								isSucces := true
// 								results, err := test[i].ClientClient.ReadDiscreteInputs(slaveID, address, quantity)
// 								if err != nil {
// 									//time.Sleep(500 * time.Millisecond)
// 									results, err = test[i].ClientClient.ReadDiscreteInputs(slaveID, address, quantity)
// 									if err != nil {
// 										//isAdd = true
// 										isSucces = false
// 									}
// 								}
// 								if isSucces {
// 									if len(results) > 0 {
// 										binaryStr := BytesToBinaryString(results)
// 										hexString := GetBinaryString(binaryStr)
// 										AddData(data2.Serial_ID, data2.ID, data3, hexString, item.CollectAddressID)
// 									} else {
// 										deleteArray(data2.Serial_ID, data2.ID, data3, *item.CollectAddressID)
// 									}
// 								}

// 							} else if data3 == 3 {
// 								//读功能码03
// 								isSucces := true
// 								results, err := test[i].ClientClient.ReadHoldingRegisters(slaveID, address, quantity)
// 								if err != nil {
// 									//util.Error("'" + GetCOMName(test[i].ComName) + "." + data2.Name + ".功能码3'读取数据失败，请检查配置情况:<br>" + err.Error())
// 									results, err = test[i].ClientClient.ReadHoldingRegisters(slaveID, address, quantity)
// 									if err != nil {
// 										isSucces = false
// 										//util.Error("'" + GetCOMName(test[i].ComName) + "." + data2.Name + ".功能码3'重新读取数据失败，请检查配置情况:<br>" + err.Error())
// 									}
// 									//time.Sleep(100 * time.Millisecond)
// 									//}
// 									//}()
// 								}
// 								if isSucces {
// 									if len(results) > 0 {
// 										hexString := GetModbusData(results)
// 										AddData(data2.Serial_ID, data2.ID, data3, hexString, item.CollectAddressID)
// 									} else {
// 										deleteArray(data2.Serial_ID, data2.ID, data3, *item.CollectAddressID)
// 									}
// 								}

// 							} else if data3 == 4 {
// 								//读功能码04
// 								isSucces := true
// 								results, err := test[i].ClientClient.ReadInputRegisters(slaveID, address, quantity)
// 								if err != nil {
// 									results, err = test[i].ClientClient.ReadInputRegisters(slaveID, address, quantity)
// 									if err != nil {
// 										isSucces = false
// 										//util.Error("'" + GetCOMName(test[i].ComName) + "." + data2.Name + ".功能码4'重新读取数据失败，请检查配置情况:<br>" + err.Error())
// 									}
// 								}
// 								if isSucces {
// 									if len(results) > 0 {
// 										hexString := GetModbusData(results)
// 										AddData(data2.Serial_ID, data2.ID, data3, hexString, item.CollectAddressID)
// 									} else {
// 										deleteArray(data2.Serial_ID, data2.ID, data3, *item.CollectAddressID)
// 									}
// 								}

// 							}
// 							//mu.Unlock()
// 						}
// 					}
// 					//}

// 				}

// 			}
// 		}()
// 	}
// }

// // var i2 = 0
// // var i3 = 0

// func GetDataTime() {
// 	//i2++

// 	//fmt.Println("再次进入", i2)
// 	//fmt.Println("i3", i3)
// 	//i3 = 0
// 	var wg sync.WaitGroup
// 	for i2, _ := range test {
// 		wg.Add(1)
// 		i := i2

// 		go func() {
// 			defer wg.Done()
// 			//mu.Lock()
// 			// defer mu.Unlock()
// 			for j := range util.Serial_Slave {

// 				data2 := util.Serial_Slave[j]
// 				if data2.Serial_ID == test[i].DataID {
// 					//获取该串口的地址位
// 					slaveIds, err := strconv.Atoi(data2.ModbusSlaveID)
// 					if err != nil {
// 						util.Error(data2.Name + "地址位转换失败")
// 					}
// 					slaveID := byte(slaveIds)
// 					for _, item := range util.Serial_Slave_Detail {
// 						if item.Serial_ID == test[i].DataID && item.Serial_Slave_ID == data2.ID {
// 							//fmt.Println("k", k)
// 							//i3++
// 							time.Sleep(200 * time.Millisecond)
// 							address := uint16(*item.CollectAddressID) // 寄存器起始地址
// 							quantity := uint16(1)                     // 寄存器数量
// 							data3 := item.Type
// 							if data3 == 1 {
// 								//读功能码01
// 								isSucces := true
// 								results, err := test[i].ClientClient.ReadCoils(slaveID, address, quantity)
// 								if err != nil {
// 									for k := 0; k < util.RetryCount; k++ {
// 										results, err = test[i].ClientClient.ReadCoils(slaveID, address, quantity)
// 										if err != nil {
// 											//fmt.Printf("重连第%d次\n", k)
// 											isSucces = false
// 										} else {
// 											isSucces = true
// 											break
// 										}
// 									}

// 								}
// 								if isSucces {
// 									if len(results) > 0 {
// 										// binaryStr := BytesToBinaryString(results)
// 										// hexString := GetBinaryString(binaryStr)
// 										// fmt.Println("results", results)
// 										// fmt.Println("binaryStr", binaryStr)
// 										// fmt.Println("hexString", hexString)
// 										hexString := GetModbusData(results)
// 										AddData(data2.Serial_ID, data2.ID, data3, hexString, item.CollectAddressID)
// 									} else {
// 										deleteArray(data2.Serial_ID, data2.ID, data3, *item.CollectAddressID)
// 									}
// 								}

// 							} else if data3 == 2 {
// 								//读功能码02
// 								isSucces := true
// 								results, err := test[i].ClientClient.ReadDiscreteInputs(slaveID, address, quantity)
// 								// if err != nil {
// 								// 	//time.Sleep(500 * time.Millisecond)
// 								// 	results, err = test[i].ClientClient.ReadDiscreteInputs(slaveID, address, quantity)
// 								// 	if err != nil {
// 								// 		//isAdd = true
// 								// 		isSucces = false
// 								// 	}
// 								// }
// 								if err != nil {
// 									for k := 0; k < util.RetryCount; k++ {
// 										results, err = test[i].ClientClient.ReadDiscreteInputs(slaveID, address, quantity)
// 										if err != nil {
// 											//fmt.Printf("重连第%d次\n", k)
// 											isSucces = false
// 										} else {
// 											isSucces = true
// 											break
// 										}
// 									}

// 								}
// 								if isSucces {
// 									if len(results) > 0 {
// 										// binaryStr := BytesToBinaryString(results)
// 										// hexString := GetBinaryString(binaryStr)
// 										hexString := GetModbusData(results)
// 										AddData(data2.Serial_ID, data2.ID, data3, hexString, item.CollectAddressID)
// 									} else {
// 										deleteArray(data2.Serial_ID, data2.ID, data3, *item.CollectAddressID)
// 									}
// 								}

// 							} else if data3 == 3 {
// 								//读功能码03
// 								isSucces := true
// 								results, err := test[i].ClientClient.ReadHoldingRegisters(slaveID, address, quantity)
// 								// if err != nil {
// 								// 	//util.Error("'" + GetCOMName(test[i].ComName) + "." + data2.Name + ".功能码3'读取数据失败，请检查配置情况:<br>" + err.Error())
// 								// 	results, err = test[i].ClientClient.ReadHoldingRegisters(slaveID, address, quantity)
// 								// 	if err != nil {
// 								// 		isSucces = false
// 								// 		//util.Error("'" + GetCOMName(test[i].ComName) + "." + data2.Name + ".功能码3'重新读取数据失败，请检查配置情况:<br>" + err.Error())
// 								// 	}
// 								// }
// 								if err != nil {
// 									for k := 0; k < util.RetryCount; k++ {
// 										results, err = test[i].ClientClient.ReadHoldingRegisters(slaveID, address, quantity)
// 										if err != nil {
// 											//fmt.Printf("重连第%d次\n", k)
// 											isSucces = false
// 										} else {
// 											isSucces = true
// 											break
// 										}
// 									}

// 								}
// 								if isSucces {
// 									if len(results) > 0 {
// 										hexString := GetModbusData(results)
// 										AddData(data2.Serial_ID, data2.ID, data3, hexString, item.CollectAddressID)
// 									} else {
// 										deleteArray(data2.Serial_ID, data2.ID, data3, *item.CollectAddressID)
// 									}
// 								}

// 							} else if data3 == 4 {
// 								//读功能码04
// 								isSucces := true
// 								results, err := test[i].ClientClient.ReadInputRegisters(slaveID, address, quantity)
// 								// if err != nil {
// 								// 	results, err = test[i].ClientClient.ReadInputRegisters(slaveID, address, quantity)
// 								// 	if err != nil {
// 								// 		isSucces = false
// 								// 		//util.Error("'" + GetCOMName(test[i].ComName) + "." + data2.Name + ".功能码4'重新读取数据失败，请检查配置情况:<br>" + err.Error())
// 								// 	}
// 								// }
// 								if err != nil {
// 									for k := 0; k < util.RetryCount; k++ {
// 										results, err = test[i].ClientClient.ReadInputRegisters(slaveID, address, quantity)
// 										if err != nil {
// 											//fmt.Printf("重连第%d次\n", k)
// 											isSucces = false
// 										} else {
// 											isSucces = true
// 											break
// 										}
// 									}

// 								}
// 								if isSucces {
// 									if len(results) > 0 {
// 										hexString := GetModbusData(results)
// 										AddData(data2.Serial_ID, data2.ID, data3, hexString, item.CollectAddressID)
// 									} else {
// 										deleteArray(data2.Serial_ID, data2.ID, data3, *item.CollectAddressID)
// 									}
// 								}

// 							}
// 							//mu.Unlock()
// 						}
// 					}
// 					//}

// 				}

// 			}
// 		}()
// 	}
// 	wg.Wait()
// }

// // 把出错的串口功能码去除
// func deleteArray(serial_ID int64, serial_Slave_ID int64, types int64, collectAddressID int64) string {
// 	for i, item := range util.Serial_Slave_Detail {
// 		if item.Serial_ID == serial_ID && item.Serial_Slave_ID == serial_Slave_ID && item.Type == types && *item.CollectAddressID == collectAddressID {
// 			util.Serial_Slave_Detail = append(util.Serial_Slave_Detail[:i], util.Serial_Slave_Detail[i+1:]...)
// 			return item.Name
// 			//break
// 		}
// 	}
// 	return ""
// }

// // 将获取的数据插入对应的位置
// func AddData(serial_ID int64, serial_Slave_ID int64, types int64, collectData string, CollectAddressID *int64) {
// 	//fmt.Println("adddata", serial_ID, serial_Slave_ID, types, collectData)
// 	for i := 0; i < len(util.Serial_Slave_Detail); i++ {
// 		data := util.Serial_Slave_Detail[i]
// 		if data.Serial_ID == serial_ID && data.Serial_Slave_ID == serial_Slave_ID && data.Type == types && data.CollectAddressID == CollectAddressID {
// 			//cdata := collectData[(*data.CollectAddressID * 4) : *data.CollectAddressID*4+4] //需要采集位置的数据
// 			test1 := dto.Serial_Slave_Detail_Cache{
// 				ID:               data.ID,
// 				Serial_ID:        data.Serial_ID,
// 				Serial_Slave_ID:  data.Serial_Slave_ID,
// 				CollectAddressID: *data.CollectAddressID,
// 				Type:             data.Type,
// 				Value:            collectData,
// 				CreateTime:       time.Now().Format("2006-01-02 15:04:05"),
// 			}
// 			// 在 append 之前，遍历 collectDataListNew，根据 ID 判断是否需要覆盖
// 			updated := false
// 			for i, data := range util.CollectDataList {
// 				if data.ID == test1.ID {
// 					// 找到相同 ID 的元素，进行覆盖
// 					util.CollectDataList[i] = test1
// 					updated = true
// 					break
// 				}
// 			}
// 			// 如果没有找到相同 ID 的元素，进行追加
// 			if !updated {
// 				util.CollectDataList = append(util.CollectDataList, test1)
// 			}
// 			//collectDataListNew = append(collectDataListNew, test1)
// 		}
// 		// if len(collectDataListNew) > 0 && len(util.Serial_Slave_Detail) == len(collectDataListNew) {
// 		// 	//清空重置
// 		// 	collectDataList = collectDataListNew
// 		// 	collectDataListNew = collectDataList[:0]

// 		// }
// 	}
// }
// func AddDataOld(serial_ID int64, serial_Slave_ID int64, types int64, collectData string) {
// 	fmt.Println("adddata", serial_ID, serial_Slave_ID, types, collectData)
// 	for i := 0; i < len(util.Serial_Slave_Detail); i++ {
// 		data := util.Serial_Slave_Detail[i]
// 		if data.Serial_ID == serial_ID && data.Serial_Slave_ID == serial_Slave_ID && data.Type == types {
// 			cdata := collectData[(*data.CollectAddressID * 4) : *data.CollectAddressID*4+4] //需要采集位置的数据
// 			test1 := dto.Serial_Slave_Detail_Cache{
// 				ID:               data.ID,
// 				Serial_ID:        data.Serial_ID,
// 				Serial_Slave_ID:  data.Serial_Slave_ID,
// 				CollectAddressID: *data.CollectAddressID,
// 				Type:             data.Type,
// 				Value:            cdata,
// 				CreateTime:       time.Now().Format("2006-01-02 15:04:05"),
// 			}
// 			// 在 append 之前，遍历 collectDataListNew，根据 ID 判断是否需要覆盖
// 			updated := false
// 			for i, data := range util.CollectDataList {
// 				if data.ID == test1.ID {
// 					// 找到相同 ID 的元素，进行覆盖
// 					util.CollectDataList[i] = test1
// 					updated = true
// 					break
// 				}
// 			}
// 			// 如果没有找到相同 ID 的元素，进行追加
// 			if !updated {
// 				util.CollectDataList = append(util.CollectDataList, test1)
// 			}
// 			//collectDataListNew = append(collectDataListNew, test1)
// 		}
// 		// if len(collectDataListNew) > 0 && len(util.Serial_Slave_Detail) == len(collectDataListNew) {
// 		// 	//清空重置
// 		// 	collectDataList = collectDataListNew
// 		// 	collectDataListNew = collectDataList[:0]

// 		// }
// 	}
// }

// // 对应开启的功能码 [3,4]
// func GetTypesBySerialSlaveID(serialSlaveID int64) []int64 {
// 	var types []int64
// 	for _, item := range util.Serial_Slave_Detail {
// 		if item.Serial_Slave_ID == serialSlaveID {
// 			types = append(types, item.Type)
// 		}
// 	}
// 	type2 := RemoveDuplicates(types)
// 	return type2
// }

// // 十进制转为8位的二进制 功能码1和2使用 比如[66 68] 转为  0100 0010 0100 0100
// func BytesToBinaryString(bytes []byte) string {
// 	binaryString := ""
// 	for _, b := range bytes {
// 		c := fmt.Sprintf("%08b", b)
// 		binaryString += ReverseBinary(c) //比如 0100 0010 0100 0100   转为 0100 0010 0010 0010

// 	}
// 	return binaryString
// }

// // 将二进制倒序排 功能码1和2使用  比如 1234 转为 4321
// func ReverseBinary(binaryStr string) string {
// 	var reversedBinary string
// 	for i := len(binaryStr) - 1; i >= 0; i-- {
// 		reversedBinary += string(binaryStr[i])
// 	}
// 	return reversedBinary
// }

// // 将每一个位转成4位二进制 功能码1和2使用 比如1101 转为 0001 0001 0000 0001
// func GetBinaryString(a string) string {

// 	c := ""
// 	for i := 0; i < len(a); i++ {
// 		b, _ := strconv.ParseInt(a[i:i+1], 10, 64)
// 		c += fmt.Sprintf("%04b", b)
// 	}
// 	return c
// }

// // 串口主设置
// func GetSerialInit() {
// 	Serial := []models.Serial{}
// 	db := db.GetDB()
// 	//查询所有文章,以及文章的分类Preload
// 	db.Preload("Serial_Slave").Preload("Serial_Slave.Serial_Slave_Detail").Find(&Serial)

// 	util.Serial = Serial
// }

// // 串口设备设置
// func GetSerial_SlavelInit() {
// 	db := db.GetDB()
// 	var data []models.Serial_Slave
// 	db.Find(&data)
// 	if len(data) == 0 {
// 		util.Error("串口设备数据未配置")
// 	}
// 	util.Serial_Slave = data
// }

// // 串口设备功能码设置
// func Serial_Slave_DetailInit() {
// 	db := db.GetDB()
// 	var data []models.Serial_Slave_Detail
// 	db.Find(&data)
// 	if len(data) == 0 {
// 		util.Error("串口设备功能码数据未配置")
// 	}
// 	util.Serial_Slave_Detail = data
// 	var data2 []models.Serial_Slave_Detail
// 	for _, d := range data {
// 		if d.Type != 0 {
// 			data2 = append(data2, d)
// 		}

// 	}
// 	//countBreak = len(data2)
// 	//count = len(data2)
// }
